package com.linx.notice.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.linx.common.core.domain.R;
import com.linx.common.core.utils.MapstructUtils;
import com.linx.common.core.utils.StringUtils;
import com.linx.common.mybatis.core.page.PageQuery;
import com.linx.common.mybatis.core.page.TableDataInfo;
import com.linx.notice.domain.InfoScope;
import com.linx.notice.domain.InfoScopeUser;
import com.linx.notice.domain.bo.InfoScopeBo;
import com.linx.notice.domain.vo.InfoScopeVo;
import com.linx.notice.domain.vo.UserVo;
import com.linx.notice.mapper.InfoScopeMapper;
import com.linx.notice.mapper.InfoScopeUserMapper;
import com.linx.notice.service.IInfoScopeService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 信息发布—发送范围管理Service业务层处理
 *
 * @author 泽智科技
 * @date 2024-10-21
 */
@RequiredArgsConstructor
@Service
public class InfoScopeServiceImpl implements IInfoScopeService {

    private final InfoScopeMapper baseMapper;
    private final InfoScopeUserMapper scopeUserMapper;


    /**
     * 查询信息发布—发送范围管理
     *
     * @param infoScopeId 主键
     * @return 信息发布—发送范围管理
     */
    @Override
    public InfoScopeVo queryById(Long infoScopeId){
        InfoScopeVo vo = baseMapper.selectVoById(infoScopeId);
        List<Long> userIds = scopeUserMapper.selectUserIdsByScopeId(infoScopeId);
        vo.setUserIds(userIds);
        return vo;
    }

    /**
     * 分页查询信息发布—发送范围管理列表
     *
     * @param bo        查询条件
     * @param pageQuery 分页参数
     * @return 信息发布—发送范围管理分页列表
     */
    @Override
    public TableDataInfo<InfoScopeVo> queryPageList(InfoScopeBo bo, PageQuery pageQuery) {
//        LambdaQueryWrapper<InfoScope> lqw = buildQueryWrapper(bo);
        Page<InfoScopeVo> result = baseMapper.selectVoPageNew(bo,pageQuery.build());
        return TableDataInfo.build(result);
    }

    /**
     * 查询符合条件的信息发布—发送范围管理列表
     *
     * @param bo 查询条件
     * @return 信息发布—发送范围管理列表
     */
    @Override
    public List<InfoScopeVo> queryList(InfoScopeBo bo) {
        LambdaQueryWrapper<InfoScope> lqw = buildQueryWrapper(bo);
        return baseMapper.selectVoList(lqw);
    }

    private LambdaQueryWrapper<InfoScope> buildQueryWrapper(InfoScopeBo bo) {
        LambdaQueryWrapper<InfoScope> lqw = Wrappers.lambdaQuery();
        lqw.like(StringUtils.isNotBlank(bo.getScopeName()), InfoScope::getScopeName, bo.getScopeName());
        return lqw;
    }

    /**
     * 新增信息发布—发送范围管理
     *
     * @param bo 信息发布—发送范围管理
     * @return 是否新增成功
     */
    @Override
    public Boolean insertByBo(InfoScopeBo bo) {
        InfoScope add = MapstructUtils.convert(bo, InfoScope.class);
        QueryWrapper<InfoScope> queryWrapper = new QueryWrapper();
        queryWrapper.eq("scope_name",bo.getScopeName());
        List<InfoScopeVo> list = baseMapper.selectVoList(queryWrapper);
        if(list.size()>0){
            return false;
        }
        validEntityBeforeSave(add);
        boolean flag = baseMapper.insert(add) > 0;
        if (flag) {
            bo.setInfoScopeId(add.getInfoScopeId());
            if (bo.getUserIds().size()>0){
                List<InfoScopeUser> infoScopeUserBoList = bo.getUserIds().stream().map(e->{
                    InfoScopeUser scopeUserBo = new InfoScopeUser();
                    scopeUserBo.setUserId(e);
                    scopeUserBo.setInfoScopeId(bo.getInfoScopeId());
                    return  scopeUserBo;
                }).collect(Collectors.toList());
                scopeUserMapper.insertBatch(infoScopeUserBoList);
            }
        }
        return flag;
    }

    /**
     * 修改信息发布—发送范围管理
     *
     * @param bo 信息发布—发送范围管理
     * @return 是否修改成功
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean updateByBo(InfoScopeBo bo) {
        InfoScope update = MapstructUtils.convert(bo, InfoScope.class);
        validEntityBeforeSave(update);
        boolean flag =baseMapper.updateById(update) > 0;

        if (flag) {
            bo.setInfoScopeId(update.getInfoScopeId());
            if (bo.getUserIds().size()>0){
                List<InfoScopeUser> infoScopeUserBoList = bo.getUserIds().stream().map(e->{
                    InfoScopeUser scopeUserBo = new InfoScopeUser();
                    scopeUserBo.setUserId(e);
                    scopeUserBo.setInfoScopeId(bo.getInfoScopeId());
                    //查询用户信息园区信息

                    return  scopeUserBo;
                }).collect(Collectors.toList());
                //根据InfoScopeId删除数据
                scopeUserMapper.delete(new LambdaQueryWrapper<InfoScopeUser>().eq(InfoScopeUser::getInfoScopeId,bo.getInfoScopeId()));
                scopeUserMapper.insertBatch(infoScopeUserBoList);
            }else {
                scopeUserMapper.delete(new LambdaQueryWrapper<InfoScopeUser>().eq(InfoScopeUser::getInfoScopeId,bo.getInfoScopeId()));
            }
        }

        return flag;
    }

    /**
     * 保存前的数据校验
     */
    private void validEntityBeforeSave(InfoScope entity){
        //TODO 做一些数据校验,如唯一约束
    }

    /**
     * 校验并批量删除信息发布—发送范围管理信息
     *
     * @param ids     待删除的主键集合
     * @param isValid 是否进行有效性校验
     * @return 是否删除成功
     */
    @Override
    public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
        if(isValid){
            //TODO 做一些业务上的校验,判断是否需要校验
        }
        return baseMapper.deleteByIds(ids) > 0;
    }

    @Override
    public R<List<UserVo>> getUserList() {
        List<UserVo> list = scopeUserMapper.selectUserList();
        return R.ok(list);
    }
}
